# LeetCode 56、合并区间

# 一、题目描述

以数组 intervals 表示若干个区间的集合,其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间,并返回 一个不重叠的区间数组,该数组需恰好覆盖输入中的所有区间

示例 1:

输入:intervals = [[1,3],[2,6],[8,10],[15,18]]
输出:[[1,6],[8,10],[15,18]]
解释:区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2:

输入:intervals = [[1,4],[4,5]]
输出:[[1,5]]
解释:区间 [1,4] 和 [4,5] 可被视为重叠区间。 

提示:

  • 1 <= intervals.length <= 10^4
  • intervals[i].length == 2
  • 0 <= starti <= endi <= 10^4

# 二、题目解析

# 三、参考代码

# 1、Java 代码

// 登录 AlgoMooc 官网获取更多算法图解
// https://www.algomooc.com
// 作者:程序员吴师兄
// 代码有看不懂的地方一定要私聊咨询吴师兄呀
// https://leetcode-cn.com/problems/merge-intervals/
class Solution {
    public int[][] merge(int[][] intervals) {

        //通过 sort 函数对二维数组每一行按第一列元素进行排序
        //重写比较器方法,o1[] - o2[] 表示当 o1 大于 o2 时,将 o1 放在 o2 后面,即基本的升序排序
        //而 o1[0] - o2[0] 表示按二维数组的每一行第一列元素排序,类似的 o[1] - o2[1]代表按第二列进行排序
        Arrays.sort(intervals, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0] - o2[0];
            }
        });

        // 最终的合并区间
        List<int[]> result = new ArrayList<int[]>();

        for (int i = 0; i < intervals.length; i++) {

            // 比如 intervals = [[1,3],[2,6],[8,10],[15,18]]
            // i = 1
            // intervals[i] = [2,6]

            // left 表示第 i 个数组的最左边那个元素
            // left = 2
            int left = intervals[i][0];

            // left 表示第 i 个数组的最右边那个元素
            // right = 6
            int right = intervals[i][1];


            // 一开始,result 为空,那么遇到第一个区间,可以直接把它加进去
            if(result.size() == 0 ){
                
                // 直接把当前的区间加入到 reslut
                result.add(intervals[i]);

                // 开始执行下一次循环
                continue;
            }

            // 如果 result 不为空,里面存在区间
            // 那么需要判断一下,result 里面的最后一个区间的最右端是否可以和 left 重合
            int[] last = result.get(result.size() - 1);

            // 如果发现最后一个区间的最右端在 left 的左侧,说明此时无法合并
            if( last[1] < left ){

                // 直接把当前的区间加入到 reslut
                result.add(intervals[i]);

            // 否则,说明需要合并
            // 将 result 的最后一项的 right 进行更新
            }else{

                // 此时,last[1] >= left 了,需要判断一下 last[1] 和 right 的大小
                int newRight = Math.max(last[1],right);

                // 把较大值作为这个区间的最右端
                result.get(result.size() - 1)[1] = newRight;

            }

        }


        // 最后,将 list 转二维数组
        return result.toArray(new int[result.size()][]);
    }
}

# **2、**C++ 代码

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        //通过 sort 函数对二维数组每一行按第一列元素进行排序
        //重写比较器方法,o1[] - o2[] 表示当 o1 大于 o2 时,将 o1 放在 o2 后面,即基本的升序排序
        //而 o1[0] - o2[0] 表示按二维数组的每一行第一列元素排序,类似的 o[1] - o2[1]代表按第二列进行排序
        sort(intervals.begin(), intervals.end());


        // 最终的合并区间
        vector<vector<int>> result;

        for (int i = 0; i < intervals.size(); i++) {

            // 比如 intervals = [[1,3],[2,6],[8,10],[15,18]]
            // i = 1
            // intervals[i] = [2,6]

            // left 表示第 i 个数组的最左边那个元素
            // left = 2
            int left = intervals[i][0];

            // left 表示第 i 个数组的最右边那个元素
            // right = 6
            int right = intervals[i][1];


            // 一开始,result 为空,那么遇到第一个区间,可以直接把它加进去
            if(result.size() == 0 ){
                
                // 直接把当前的区间加入到 reslut
                result.push_back(intervals[i]);

                // 开始执行下一次循环
                continue;
            }

            // 如果 result 不为空,里面存在区间
            // 那么需要判断一下,result 里面的最后一个区间的最右端是否可以和 left 重合
            // int[] last = result.back();

            // 如果发现最后一个区间的最右端在 left 的左侧,说明此时无法合并
            if( result.back()[1] < left ){

                // 直接把当前的区间加入到 reslut
                result.push_back(intervals[i]);

            // 否则,说明需要合并
            // 将 result 的最后一项的 right 进行更新
            }else{

                // 此时,last[1] >= left 了,需要判断一下 last[1] 和 right 的大小
                int newRight = max(result.back()[1],right);

                // 把较大值作为这个区间的最右端
                result.back()[1] = newRight;

            }

        }


        // 最后,将 list 转二维数组
        return result;

    }
};

# 3、Python 代码

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:

        intervals.sort(key=lambda x: x[0])

        # 最终的合并区间
        result = []

        for i in range(len(intervals)) :

            # 比如 intervals = [[1,3],[2,6],[8,10],[15,18]]
            # i = 1
            # intervals[i] = [2,6]

            # left 表示第 i 个数组的最左边那个元素
            # left = 2
            left = intervals[i][0]

            # left 表示第 i 个数组的最右边那个元素
            # right = 6
            right = intervals[i][1]


            # 一开始,result 为空,那么遇到第一个区间,可以直接把它加进去
            if not result :
                
                # 直接把当前的区间加入到 reslut
                result.append(intervals[i])

                # 开始执行下一次循环
                continue
            


            # 如果 result 不为空,里面存在区间
            # 那么需要判断一下,result 里面的最后一个区间的最右端是否可以和 left 重合
            last = result[-1]

            # 如果发现最后一个区间的最右端在 left 的左侧,说明此时无法合并
            if  last[1] < left :

                # 直接把当前的区间加入到 reslut
                result.append(intervals[i])

            # 否则,说明需要合并
            # 将 result 的最后一项的 right 进行更新
            else:

                # 此时,last[1] >= left 了,需要判断一下 last[1] 和 right 的大小
                newRight = max(last[1],right)

                # 把较大值作为这个区间的最右端
                result[-1][1] = newRight

        # 最后,将 list 转二维数组
        return result

# 四、复杂度分析

时间复杂度:O(nlogn)

空间复杂度:O(logn)